package org.example.sysrole.mapper;

import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import org.example.sysrole.entity.SysRole;


import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 系统角色持久层（基于 Db 工具类重构）
 */
public class SysRoleMapper {

    private static final String TABLE_NAME = "sys_role";

    /**
     * 插入系统角色
     *
     * @param sysRole 系统角色对象
     * @return 插入成功返回影响行数，失败返回0
     */
    public int insertSysRole(SysRole sysRole) {
        if (sysRole == null) {
            throw new RuntimeException("角色信息不能为空");
        }

        String roleName = sysRole.getRoleName();
        if (roleName == null || roleName.trim().isEmpty()) {
            throw new RuntimeException("角色名称不能为空");
        }

        // 1. 校验角色名是否已存在
        try {
            Entity check = Entity.create(TABLE_NAME)
                    .set("role_name", roleName);

            List<Entity> list = Db.use().find(check);
            if (list != null && !list.isEmpty()) {
                throw new RuntimeException("角色名称【" + roleName + "】已存在");
            }
        } catch (SQLException e) {
            throw new RuntimeException("检查角色名是否存在失败", e);
        }

        // 2. 构造插入数据
        Entity entity = Entity.create(TABLE_NAME)
                .set("role_name", sysRole.getRoleName())
                .set("role_key", sysRole.getRoleKey())
                .set("role_sort", sysRole.getRoleSort())
                .set("status", sysRole.getStatus())
                .set("del_flag", sysRole.getDelFlag());

        // 3. 执行插入
        try {
            return Db.use().insert(entity);
        } catch (SQLException e) {
            throw new RuntimeException("插入角色失败", e);
        }
    }

    /**
     * 删除系统角色（物理删除）
     *
     * @param roleId 角色ID
     * @return 删除成功返回影响行数
     */
    public int deleteSysRole(Long roleId) {
        if (roleId == null) {
            throw new RuntimeException("角色ID不能为空");
        }

        // 1. 先查询角色是否存在
        Entity query = Entity.create(TABLE_NAME).set("role_id", roleId);
        Entity role;
        try {
            List<Entity> list = Db.use().find(query);
            role = (list != null && !list.isEmpty()) ? list.get(0) : null;
        } catch (SQLException e) {
            throw new RuntimeException("查询角色失败", e);
        }

        if (role == null) {
            throw new RuntimeException("无法删除，角色ID【" + roleId + "】不存在");
        }

        // 2. 执行删除
        Entity where = Entity.create(TABLE_NAME).set("role_id", roleId);
        try {
            int rows = Db.use().del(where);
            if (rows <= 0) {
                throw new RuntimeException("删除失败，未影响任何记录");
            }
            return rows;
        } catch (SQLException e) {
            throw new RuntimeException("删除角色时发生异常", e);
        }
    }

    public int updateSysRole(SysRole sysRole) {
        if (sysRole == null || sysRole.getRoleId() == null) {
            throw new RuntimeException("角色ID不能为空");
        }

        Long roleId = sysRole.getRoleId();
        String roleName = sysRole.getRoleName();

        // 1. 校验角色是否存在
        Entity existing = Entity.create(TABLE_NAME).set("role_id", roleId);
        List<Entity> result;
        try {
            result = Db.use().find(existing);
        } catch (SQLException e) {
            throw new RuntimeException("查询角色失败", e);
        }

        if (result == null || result.isEmpty()) {
            throw new RuntimeException("角色不存在，ID：" + roleId);
        }

        // 2. 校验角色名是否重复（排除自己）
        if (roleName != null && !roleName.equals(result.get(0).getStr("role_name"))) {
            try {
                Number number = Db.use().queryNumber(
                        "SELECT COUNT(*) FROM sys_role WHERE role_name = ? AND role_id != ?",
                        roleName,
                        roleId
                );
                Long count = (number != null) ? number.longValue() : 0L;

                if (count != null && count > 0) {
                    throw new RuntimeException("角色名称【" + roleName + "】已存在");
                }
            } catch (SQLException e) {
                throw new RuntimeException("检查角色名失败", e);
            }
        }

        // 3. 构造更新内容并执行更新
        Entity update = Entity.create(TABLE_NAME)
                .set("role_name", sysRole.getRoleName())
                .set("role_key", sysRole.getRoleKey())
                .set("status", sysRole.getStatus())
                .set("del_flag", sysRole.getDelFlag());

        Entity where = Entity.create(TABLE_NAME)
                .set("role_id", roleId);

        try {
            return Db.use().update(update, where);
        } catch (SQLException e) {
            throw new RuntimeException("更新失败", e);
        }
    }

    /**
     * 根据角色ID查询系统角色
     *
     * @param roleId 角色ID
     * @return 返回查询到的角色对象，如果未找到则返回 null
     */
    public SysRole selectSysRole(Long roleId) {
        if (roleId == null) {
            return null;
        }

        try {
            Entity where = Entity.create(TABLE_NAME).set("role_id", roleId);
            List<Entity> list = Db.use().find(where);

            if (list != null && !list.isEmpty()) {
                return toSysRole(list.get(0));
            }
        } catch (SQLException e) {
            throw new RuntimeException("数据库查询失败: " + e.getMessage(), e);
        }

        return null;
    }
    /**
     * 分页/条件查询系统角色列表
     *
     * @param sysRole 查询条件对象，可以为 null 表示无条件查询
     * @return 返回符合条件的角色列表
     */
    public List<SysRole> selectSysRoleList(SysRole sysRole) {
        Entity query = Entity.create(TABLE_NAME);

        // 如果有查询条件
        if (sysRole != null) {
            if (sysRole.getRoleName() != null && !sysRole.getRoleName().isEmpty()) {
                query.set("role_name", "like %" + sysRole.getRoleName() + "%");
            }
            if (sysRole.getStatus() != null && !sysRole.getStatus().isEmpty()) {
                query.set("status", sysRole.getStatus());
            }
        }

        List<Entity> results = null;
        try {
            results = Db.use().find(query);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        List<SysRole> list = new ArrayList<>();

        for (Entity entity : results) {
            list.add(toSysRole(entity));
        }

        return list;
    }
    private SysRole toSysRole(Entity entity) {
        SysRole sysRole = new SysRole();

        // 非空判断和类型安全获取
        sysRole.setRoleId(entity.getLong("role_id")); // Long 类型
        sysRole.setRoleName(entity.getStr("role_name")); // String 类型
        sysRole.setRoleKey(entity.getStr("role_key")); // String 类型
        sysRole.setStatus(entity.getStr("status")); // String 类型
        sysRole.setDelFlag(entity.getStr("del_flag")); // String 类型

        // 对于 int 类型字段 role_sort，使用 getInt，注意默认值 0
        Integer roleSort = entity.getInt("role_sort");
        sysRole.setRoleSort(roleSort == null ? 0 : roleSort); // 避免 null 转 int 报错

        return sysRole;
    }
}

